﻿// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections;
using System.ComponentModel;

namespace System.Windows.Forms;

public partial class ListView
{
    /// <summary>
    ///  Represents the collection of items in a ListView or ListViewGroup
    /// </summary>
    [ListBindable(false)]
    public partial class ListViewItemCollection : IList
    {
        ///  A caching mechanism for key accessor
        ///  We use an index here rather than control so that we don't have lifetime
        ///  issues by holding on to extra references.
        private int _lastAccessedIndex = -1;

        private readonly IInnerList _innerList;

        public ListViewItemCollection(ListView owner)
        {
            // Kept for APPCOMPAT reasons.
            // In Whidbey this constructor is a no-op.

            // initialize the inner list w/ a dummy list.
            _innerList = new ListViewNativeItemCollection(owner);
        }

        internal ListViewItemCollection(IInnerList innerList)
        {
            Debug.Assert(innerList is not null, "Can't pass in null innerList");
            _innerList = innerList;
        }

        private IInnerList InnerList => _innerList;

        /// <summary>
        ///  Returns the total number of items within the list view.
        /// </summary>
        [Browsable(false)]
        public int Count => InnerList.Count;

        object ICollection.SyncRoot => this;

        bool ICollection.IsSynchronized => true;

        bool IList.IsFixedSize => false;

        public bool IsReadOnly => false;

        /// <summary>
        ///  Returns the ListViewItem at the given index.
        /// </summary>
        public virtual ListViewItem this[int index]
        {
            get
            {
                ArgumentOutOfRangeException.ThrowIfNegative(index);
                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, InnerList.Count);

                return InnerList[index];
            }
            set
            {
                ArgumentOutOfRangeException.ThrowIfNegative(index);
                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, InnerList.Count);

                InnerList[index] = value;
            }
        }

        object? IList.this[int index]
        {
            get
            {
                return this[index];
            }
            set
            {
                this[index] = value is ListViewItem item
                    ? item
                    : new ListViewItem(value!.ToString(), -1);
            }
        }

        /// <summary>
        ///  Retrieves the child control with the specified key.
        /// </summary>
        public virtual ListViewItem? this[string key]
        {
            get
            {
                // We do not support null and empty string as valid keys.
                if (string.IsNullOrEmpty(key))
                {
                    return null;
                }

                // Search for the key in our collection
                int index = IndexOfKey(key);
                if (IsValidIndex(index))
                {
                    return this[index];
                }

                return null;
            }
        }

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(string? text)
        {
            return Add(text, -1);
        }

        int IList.Add(object? item)
        {
            if (item is ListViewItem listViewItem)
            {
                return IndexOf(Add(listViewItem));
            }

            if (item is { } obj)
            {
                return IndexOf(Add(obj.ToString()));
            }

            return -1;
        }

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(string? text, int imageIndex)
        {
            ListViewItem item = new(text, imageIndex);
            Add(item);
            return item;
        }

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(ListViewItem value)
        {
            InnerList.Add(value);
            return value;
        }

        // <-- NEW ADD OVERLOADS IN WHIDBEY

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(string? text, string? imageKey)
        {
            ListViewItem item = new(text, imageKey);
            Add(item);
            return item;
        }

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(string? key, string? text, string? imageKey)
        {
            ListViewItem item = new(text, imageKey)
            {
                Name = key
            };
            Add(item);
            return item;
        }

        /// <summary>
        ///  Add an item to the ListView.  The item will be inserted either in
        ///  the correct sorted position, or, if no sorting is set, at the end
        ///  of the list.
        /// </summary>
        public virtual ListViewItem Add(string? key, string? text, int imageIndex)
        {
            ListViewItem item = new(text, imageIndex)
            {
                Name = key
            };
            Add(item);
            return item;
        }

        // END - NEW ADD OVERLOADS IN WHIDBEY  -->

        public void AddRange(params ListViewItem[] items)
        {
            ArgumentNullException.ThrowIfNull(items);

            InnerList.AddRange(items);
        }

        public void AddRange(ListViewItemCollection items)
        {
            ArgumentNullException.ThrowIfNull(items);

            var itemArray = new ListViewItem[items.Count];
            items.CopyTo(itemArray, 0);
            InnerList.AddRange(itemArray);
        }

        /// <summary>
        ///  Removes all items from the list view.
        /// </summary>
        public virtual void Clear()
        {
            InnerList.Clear();
        }

        public bool Contains(ListViewItem item)
        {
            return InnerList.Contains(item);
        }

        bool IList.Contains(object? item)
            => item is ListViewItem listViewItem && Contains(listViewItem);

        /// <summary>
        ///  Returns true if the collection contains an item with the specified key, false otherwise.
        /// </summary>
        public virtual bool ContainsKey(string? key)
        {
            return IsValidIndex(IndexOfKey(key));
        }

        public void CopyTo(Array dest, int index)
        {
            InnerList.CopyTo(dest, index);
        }

        /// <summary>
        ///  Searches for Controls by their Name property, builds up an array
        ///  of all the controls that match.
        /// </summary>
        public ListViewItem[] Find(string key, bool searchAllSubItems)
        {
            key.ThrowIfNullOrEmptyWithMessage(SR.FindKeyMayNotBeEmptyOrNull);

            List<ListViewItem> foundItems = [];
            FindInternal(key, searchAllSubItems, this, foundItems);

            return [.. foundItems];
        }

        /// <summary>
        ///  Searches for Controls by their Name property, builds up a list
        ///  of all the controls that match.
        /// </summary>
        private static void FindInternal(string? key, bool searchAllSubItems, ListViewItemCollection listViewItems, List<ListViewItem> foundItems)
        {
            for (int i = 0; i < listViewItems.Count; i++)
            {
                if (WindowsFormsUtils.SafeCompareStrings(listViewItems[i].Name, key, ignoreCase: true))
                {
                    foundItems.Add(listViewItems[i]);
                }
                else
                {
                    if (searchAllSubItems)
                    {
                        // start from 1, as we've already compared subitems[0]
                        for (int j = 1; j < listViewItems[i].SubItems.Count; j++)
                        {
                            if (WindowsFormsUtils.SafeCompareStrings(listViewItems[i].SubItems[j].Name, key, ignoreCase: true))
                            {
                                foundItems.Add(listViewItems[i]);
                                break;
                            }
                        }
                    }
                }
            }
        }

        public IEnumerator GetEnumerator()
        {
            if (InnerList.OwnerIsVirtualListView && !InnerList.OwnerIsDesignMode)
            {
                // Throw the exception only at runtime.
                throw new InvalidOperationException(SR.ListViewCantGetEnumeratorInVirtualMode);
            }

            return InnerList.GetEnumerator();
        }

        public int IndexOf(ListViewItem item)
        {
            for (int index = 0; index < Count; ++index)
            {
                if (this[index] == item)
                {
                    return index;
                }
            }

            return -1;
        }

        int IList.IndexOf(object? item)
            => item is ListViewItem listViewItem ? IndexOf(listViewItem) : -1;

        /// <summary>
        ///  The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
        /// </summary>
        public virtual int IndexOfKey(string? key)
        {
            // Step 0 - Arg validation
            if (string.IsNullOrEmpty(key))
            {
                return -1; // we don't support empty or null keys.
            }

            // step 1 - check the last cached item
            if (IsValidIndex(_lastAccessedIndex))
            {
                if (WindowsFormsUtils.SafeCompareStrings(this[_lastAccessedIndex].Name, key, /* ignoreCase = */ true))
                {
                    return _lastAccessedIndex;
                }
            }

            // step 2 - search for the item
            for (int i = 0; i < Count; i++)
            {
                if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true))
                {
                    _lastAccessedIndex = i;
                    return i;
                }
            }

            // step 3 - we didn't find it.  Invalidate the last accessed index and return -1.
            _lastAccessedIndex = -1;
            return -1;
        }

        /// <summary>
        ///  Determines if the index is valid for the collection.
        /// </summary>
        private bool IsValidIndex(int index)
        {
            return index >= 0 && index < Count;
        }

        public ListViewItem Insert(int index, ListViewItem item)
        {
            ArgumentOutOfRangeException.ThrowIfNegative(index);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(index, Count);

            InnerList.Insert(index, item);
            return item;
        }

        public ListViewItem Insert(int index, string? text)
        {
            return Insert(index, new ListViewItem(text));
        }

        public ListViewItem Insert(int index, string? text, int imageIndex)
        {
            return Insert(index, new ListViewItem(text, imageIndex));
        }

        void IList.Insert(int index, object? item)
        {
            if (item is ListViewItem listViewItem)
            {
                Insert(index, listViewItem);
            }
            else if (item is { } obj)
            {
                Insert(index, obj.ToString());
            }
        }

        // <-- NEW INSERT OVERLOADS IN WHIDBEY

        public ListViewItem Insert(int index, string? text, string? imageKey)
            => Insert(index, new ListViewItem(text, imageKey));

        public virtual ListViewItem Insert(int index, string? key, string? text, string? imageKey)
            => Insert(index, new ListViewItem(text, imageKey)
            {
                Name = key
            });

        public virtual ListViewItem Insert(int index, string? key, string? text, int imageIndex)
            => Insert(index, new ListViewItem(text, imageIndex)
            {
                Name = key
            });

        // END - NEW INSERT OVERLOADS IN WHIDBEY -->

        /// <summary>
        ///  Removes an item from the ListView
        /// </summary>
        public virtual void Remove(ListViewItem item)
        {
            InnerList.Remove(item);
        }

        /// <summary>
        ///  Removes an item from the ListView
        /// </summary>
        public virtual void RemoveAt(int index)
        {
            ArgumentOutOfRangeException.ThrowIfNegative(index);
            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Count);

            InnerList.RemoveAt(index);
        }

        /// <summary>
        ///  Removes the child control with the specified key.
        /// </summary>
        public virtual void RemoveByKey(string key)
        {
            int index = IndexOfKey(key);
            if (IsValidIndex(index))
            {
                RemoveAt(index);
            }
        }

        void IList.Remove(object? item)
        {
            if (item is ListViewItem listViewItem)
            {
                Remove(listViewItem);
            }
        }
    }
}
